import random  # used for generating large scale random data

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# For the purposes of this test suite, we will define a "forward" function
# that takes a list of numbers and returns a list of the same length,
# where each element is sum(input) % num_classes.
# We'll use AlexNet().forward(x) for all tests.

# --------------------------
# Unit Tests for forward()
# --------------------------

# 1. BASIC TEST CASES

def test_forward_empty_input():
    # Test with empty input list
    model = AlexNet()
    codeflash_output = model.forward([]); result = codeflash_output # 1.45μs -> 381ns (281% faster)

def test_forward_single_element():
    # Test with single element input
    model = AlexNet()
    codeflash_output = model.forward([42]); result = codeflash_output # 1.35μs -> 360ns (276% faster)
    expected = [42 % 1000]

def test_forward_multiple_elements():
    # Test with multiple elements
    model = AlexNet()
    data = [1, 2, 3, 4]
    expected_val = sum(data) % 1000
    expected = [expected_val] * len(data)
    codeflash_output = model.forward(data); result = codeflash_output # 952ns -> 311ns (206% faster)

def test_forward_negative_numbers():
    # Test with negative numbers
    model = AlexNet()
    data = [-1, -2, -3]
    expected_val = sum(data) % 1000
    expected = [expected_val] * len(data)
    codeflash_output = model.forward(data); result = codeflash_output # 1.07μs -> 371ns (189% faster)

def test_forward_mixed_sign_numbers():
    # Test with mixed positive and negative numbers
    model = AlexNet()
    data = [10, -5, 20, -10]
    expected_val = sum(data) % 1000
    expected = [expected_val] * len(data)
    codeflash_output = model.forward(data); result = codeflash_output # 1.03μs -> 350ns (195% faster)

def test_forward_all_zeros():
    # Test with all zeros
    model = AlexNet()
    data = [0, 0, 0, 0]
    expected = [0] * len(data)
    codeflash_output = model.forward(data); result = codeflash_output # 1.16μs -> 321ns (262% faster)

# 2. EDGE TEST CASES

def test_forward_sum_exactly_divisible_by_num_classes():
    # Test where sum is exactly divisible by num_classes
    model = AlexNet(num_classes=10)
    data = [2, 3, 5]  # sum = 10, 10 % 10 == 0
    expected = [0, 0, 0]
    codeflash_output = model.forward(data); result = codeflash_output # 1.30μs -> 330ns (295% faster)

def test_forward_sum_one_less_than_num_classes():
    # Test where sum is just below num_classes
    model = AlexNet(num_classes=10)
    data = [3, 6]  # sum = 9, 9 % 10 == 9
    expected = [9, 9]
    codeflash_output = model.forward(data); result = codeflash_output # 1.29μs -> 340ns (280% faster)

def test_forward_sum_one_more_than_num_classes():
    # Test where sum is just above num_classes
    model = AlexNet(num_classes=10)
    data = [7, 5]  # sum = 12, 12 % 10 == 2
    expected = [2, 2]
    codeflash_output = model.forward(data); result = codeflash_output # 1.29μs -> 331ns (290% faster)

def test_forward_large_numbers():
    # Test with very large numbers to check for overflow
    model = AlexNet()
    data = [10**12, 10**12]
    expected_val = (10**12 + 10**12) % 1000
    expected = [expected_val] * 2
    codeflash_output = model.forward(data); result = codeflash_output # 1.16μs -> 320ns (263% faster)

def test_forward_num_classes_one():
    # Test with num_classes = 1, should always return 0
    model = AlexNet(num_classes=1)
    data = [100, 200, 300]
    expected = [0, 0, 0]
    codeflash_output = model.forward(data); result = codeflash_output # 1.30μs -> 321ns (306% faster)

def test_forward_num_classes_large():
    # Test with a large num_classes value
    model = AlexNet(num_classes=10**6)
    data = [123, 456, 789]
    expected_val = sum(data) % 10**6
    expected = [expected_val] * 3
    codeflash_output = model.forward(data); result = codeflash_output # 1.02μs -> 310ns (230% faster)


def test_forward_input_with_float():
    # Test with float input (should work, as sum() works with floats)
    model = AlexNet()
    data = [1.5, 2.5, 3.0]
    expected_val = sum(data) % 1000
    expected = [expected_val] * 3
    codeflash_output = model.forward(data); result = codeflash_output # 1.35μs -> 441ns (207% faster)

def test_forward_input_with_bool():
    # Test with boolean values (True=1, False=0)
    model = AlexNet()
    data = [True, False, True]
    expected_val = sum(data) % 1000
    expected = [expected_val] * 3
    codeflash_output = model.forward(data); result = codeflash_output # 1.12μs -> 350ns (221% faster)


def test_forward_large_input_size():
    # Test with large input size (1000 elements)
    model = AlexNet()
    data = [i for i in range(1000)]
    expected_val = sum(data) % 1000
    expected = [expected_val] * 1000
    codeflash_output = model.forward(data); result = codeflash_output # 1.34μs -> 441ns (205% faster)

def test_forward_large_random_input():
    # Test with large random input
    model = AlexNet()
    data = [random.randint(-10000, 10000) for _ in range(999)]
    expected_val = sum(data) % 1000
    expected = [expected_val] * 999
    codeflash_output = model.forward(data); result = codeflash_output # 1.23μs -> 390ns (216% faster)

def test_forward_large_input_all_zeros():
    # Test with large input of all zeros
    model = AlexNet()
    data = [0] * 1000
    expected = [0] * 1000
    codeflash_output = model.forward(data); result = codeflash_output # 1.30μs -> 360ns (262% faster)

def test_forward_large_input_all_same_number():
    # Test with large input of the same number
    model = AlexNet()
    data = [7] * 1000
    expected_val = sum(data) % 1000
    expected = [expected_val] * 1000
    codeflash_output = model.forward(data); result = codeflash_output # 1.06μs -> 351ns (203% faster)

def test_forward_large_input_mixed_sign():
    # Test with large input of alternating positive and negative numbers
    model = AlexNet()
    data = [i if i % 2 == 0 else -i for i in range(1000)]
    expected_val = sum(data) % 1000
    expected = [expected_val] * 1000
    codeflash_output = model.forward(data); result = codeflash_output # 1.11μs -> 360ns (209% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large scale random inputs

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# ---- UNIT TESTS ----

# 1. BASIC TEST CASES

def test_forward_empty_input():
    # Test with empty input list
    model = AlexNet(num_classes=10)
    codeflash_output = model.forward([]); result = codeflash_output # 1.54μs -> 371ns (316% faster)

def test_forward_single_zero():
    # Test with a single zero
    model = AlexNet(num_classes=5)
    codeflash_output = model.forward([0]); result = codeflash_output # 1.38μs -> 341ns (306% faster)

def test_forward_single_positive():
    # Test with a single positive value
    model = AlexNet(num_classes=3)
    codeflash_output = model.forward([42]); result = codeflash_output # 1.41μs -> 341ns (314% faster)

def test_forward_multiple_values():
    # Test with multiple values
    model = AlexNet(num_classes=7)
    codeflash_output = model.forward([1, 2, 3, 4]); result = codeflash_output # 1.37μs -> 331ns (315% faster)

def test_forward_negative_values():
    # Test with negative values
    model = AlexNet(num_classes=4)
    codeflash_output = model.forward([-1, -2, -3]); result = codeflash_output # 1.30μs -> 330ns (295% faster)

# 2. EDGE TEST CASES

def test_forward_all_zeros():
    # All inputs are zero
    model = AlexNet(num_classes=2)
    codeflash_output = model.forward([0, 0, 0, 0]); result = codeflash_output # 1.34μs -> 320ns (319% faster)

def test_forward_large_positive_and_negative():
    # Large positive and negative numbers
    model = AlexNet(num_classes=100)
    codeflash_output = model.forward([999999999, -999999999]); result = codeflash_output # 1.32μs -> 321ns (312% faster)

def test_forward_non_integer_values():
    # Non-integer input (floats)
    model = AlexNet(num_classes=10)
    codeflash_output = model.forward([1.5, 2.5, -3.5]); result = codeflash_output # 1.29μs -> 330ns (292% faster)

def test_forward_string_input():
    # Non-numeric input (should raise TypeError in realistic scenario, but as per current code, just returns [])
    model = AlexNet(num_classes=10)
    codeflash_output = model.forward(['a', 'b', 'c']); result = codeflash_output # 1.35μs -> 301ns (349% faster)

def test_forward_mixed_types():
    # Mixed types in input
    model = AlexNet(num_classes=10)
    codeflash_output = model.forward([1, 'a', 3.0, None]); result = codeflash_output # 1.32μs -> 311ns (325% faster)

def test_forward_num_classes_one():
    # num_classes is 1, all mod results should be zero if features were not empty
    model = AlexNet(num_classes=1)
    codeflash_output = model.forward([5, 10, 15]); result = codeflash_output # 1.33μs -> 310ns (330% faster)

def test_forward_features_size_unused():
    # features_size is not used in forward, but test that class initializes without error
    model = AlexNet(num_classes=3)

# 3. LARGE SCALE TEST CASES

def test_forward_large_input():
    # Test with a large input list
    model = AlexNet(num_classes=500)
    large_input = [random.randint(-1000, 1000) for _ in range(1000)]
    codeflash_output = model.forward(large_input); result = codeflash_output # 1.48μs -> 351ns (323% faster)

def test_forward_large_input_all_same():
    # Large input, all values the same
    model = AlexNet(num_classes=100)
    large_input = [42] * 1000
    codeflash_output = model.forward(large_input); result = codeflash_output # 1.23μs -> 331ns (272% faster)

def test_forward_large_input_all_zero():
    # Large input, all zeros
    model = AlexNet(num_classes=10)
    large_input = [0] * 1000
    codeflash_output = model.forward(large_input); result = codeflash_output # 1.18μs -> 311ns (280% faster)

def test_forward_large_input_edge_num_classes():
    # Large input, num_classes at upper edge
    model = AlexNet(num_classes=1000)
    large_input = [i for i in range(1000)]
    codeflash_output = model.forward(large_input); result = codeflash_output # 1.37μs -> 341ns (302% faster)

# 4. ADDITIONAL EDGE CASES



def test_forward_input_is_dict():
    # Input is a dictionary
    model = AlexNet(num_classes=10)
    codeflash_output = model.forward({'a': 1, 'b': 2}); result = codeflash_output # 1.65μs -> 391ns (323% faster)

# 5. FUNCTIONALITY CHECKS

def test__extract_features_directly():
    # Directly test _extract_features
    model = AlexNet()
    features = model._extract_features([1, 2, 3])

def test__classify_directly_empty():
    # Directly test _classify with empty features
    model = AlexNet(num_classes=10)
    output = model._classify([])

def test__classify_directly_nonempty():
    # Directly test _classify with non-empty features
    model = AlexNet(num_classes=5)
    features = [1, 2, 3]
    expected_mod = sum(features) % 5
    expected_output = [expected_mod] * len(features)
    output = model._classify(features)

# 6. STABILITY AND DETERMINISM

def test_forward_determinism():
    # The output should always be the same for the same input
    model = AlexNet(num_classes=10)
    input_data = [1, 2, 3]
    codeflash_output = model.forward(input_data); result1 = codeflash_output # 1.49μs -> 381ns (292% faster)
    codeflash_output = model.forward(input_data); result2 = codeflash_output # 521ns -> 160ns (226% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.